perm filename WEAVE.PAS[WEB,ALS]3 blob
sn#653585 filedate 1982-04-20 generic text, type C, neo UTF8
COMMENT ā VALID 00015 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00003 00002 {2}{4}{$C-,A+,D-}{[$C+,D+]}PROGRAM WEAVE(WEBFILE,CHANGEFILE,TEXFILE)
C00009 00003 PROCEDURE INITIALIZE
C00017 00004 {52}FUNCTION IDLOOKUP(T:EIGHTBITS):NAMEPOINTER
C00028 00005 {82}FUNCTION SKIPCOMMENT(BAL:EIGHTBITS):EIGHTBITS
C00041 00006 {122}FUNCTION COPYTEX:EIGHTBITS
C00049 00007 {166}{PROCEDURE PROD(N:EIGHTBITS)
C00061 00008 FUNCTION TRANSLATE:TEXTPOINTER
C00073 00009 {172}{183}PROCEDURE APPCOMMENT
C00084 00010 PROCEDURE PASCALPARSE
C00099 00011 {185}PROCEDURE OUTERPARSE
C00112 00012 {211}PROCEDURE FINISHPASCAL
C00122 00013 PROCEDURE PHASEII
C00133 00014 BEGIN INITIALIZE
C00140 00015 PHASEI
C00148 ENDMK
Cā;
{2}{4}{$C-,A+,D-}{[$C+,D+]}PROGRAM WEAVE(WEBFILE,CHANGEFILE,TEXFILE);
LABEL 9999;
CONST{8}MAXBYTES=65535;
MAXNAMES=5000;
HASHSIZE=353;
BUFSIZE=100;
LONGESTNAME=400;
LONGBUFSIZE=400;
LINELENGTH=80;
MAXREFS=20000;
MAXTOKS=20000;
MAXTEXTS=2000;
MAXSCRAPS=1000;
STACKSIZE=200;
TYPE{9}ASCIICODE=0..127;{10}TEXTFILE=PACKED FILE OF CHAR;
{34}EIGHTBITS=0..255;
SIXTEENBITS=0..65535;{36}NAMEPOINTER=0..MAXNAMES;
{46}TEXTPOINTER=0..MAXTEXTS;{188}MODE=(INNER,OUTER);
OUTPUTSTATE=RECORD ENDFIELD:SIXTEENBITS;
TOKFIELD:SIXTEENBITS;
MODEFIELD:MODE;
END;
VAR{11}XORD:ARRAY[CHAR]OF ASCIICODE;
XCHR:ARRAY[ASCIICODE]OF CHAR;{18}TERMOUT:TEXTFILE;{21}WEBFILE:TEXTFILE;
CHANGEFILE:TEXTFILE;{23}TEXFILE:TEXTFILE;
{25}BUFFER:ARRAY[0..LONGBUFSIZE]OF ASCIICODE;{27}PHASEONE:BOOLEAN;
{35}BYTEMEM:PACKED ARRAY[0..MAXBYTES]OF ASCIICODE;
BYTESTART:ARRAY[0..MAXNAMES]OF SIXTEENBITS;
LINK:ARRAY[0..MAXNAMES]OF SIXTEENBITS;
ILK:ARRAY[0..MAXNAMES]OF SIXTEENBITS;
XREF:ARRAY[0..MAXNAMES]OF SIXTEENBITS;{37}NAMEPTR:NAMEPOINTER;
BYTEPTR:0..MAXBYTES;
{42}XMEM:ARRAY[0..MAXREFS]OF PACKED RECORD NUMFIELD:SIXTEENBITS;
XLINKFIELD:SIXTEENBITS;
END;
XREFPTR:0..MAXREFS;
MODULECOUNT:0..10239;
XREFSWITCH,MODXREFSWITC:0..10240;
{47}TOKMEM:PACKED ARRAY[0..MAXTOKS]OF SIXTEENBITS;
TOKSTART:ARRAY[TEXTPOINTER]OF SIXTEENBITS;
TEXTPTR:TEXTPOINTER;
TOKPTR:0..MAXTOKS;{MAXTOKPTR,MAXTXTPTR:0..MAXTOKS;
}{49}IDFIRST:0..LONGBUFSIZE;
IDLOC:0..LONGBUFSIZE;
HASH:ARRAY[0..HASHSIZE]OF SIXTEENBITS;{57}CURNAME:NAMEPOINTER;
{59}MODTEXT:ARRAY[0..LONGESTNAME]OF ASCIICODE;{65}LINE:INTEGER;
OTHERLINE:INTEGER;
TEMPLINE:INTEGER;
LIMIT:0..LONGBUFSIZE;
LOC:0..LONGBUFSIZE;
INPUTHASENDE:BOOLEAN;
CHANGING:BOOLEAN;
{66}CHANGEBUFFER:ARRAY[0..BUFSIZE]OF ASCIICODE;
CHANGELIMIT:0..BUFSIZE;
{84}CURMODULE:NAMEPOINTER;{96}NEXTCONTROL:EIGHTBITS;
{102}LHS,RHS:NAMEPOINTER;{106}CURXREF:0..MAXREFS;
{109}OUTBUF:ARRAY[0..LINELENGTH]OF ASCIICODE;
OUTPTR:0..LINELENGTH;
OUTLINE:INTEGER;{117}DIG:ARRAY[0..4]OF 0..9;
{132}CAT:ARRAY[0..MAXSCRAPS]OF EIGHTBITS;
TRANS:ARRAY[0..MAXSCRAPS]OF TEXTPOINTER;
PP:0..MAXSCRAPS;
SCRAPBASE:0..MAXSCRAPS;
SCRAPPTR:0..MAXSCRAPS;
LOPTR:0..MAXSCRAPS;
HIPTR:0..MAXSCRAPS;{MAXSCRPTR:0..MAXSCRAPS;}{165}{TRACING:0..2;
}{189}CURSTATE:OUTPUTSTATE;
STACK:ARRAY[1..STACKSIZE]OF OUTPUTSTATE;
STACKPTR:0..STACKSIZE;{MAXSTACKPTR:0..STACKSIZE;}{206}SAVELINE:INTEGER;
SAVEPLACE:SIXTEENBITS;{214}THISMODULE:NAMEPOINTER;
{223}BUCKET:ARRAY[ASCIICODE]OF NAMEPOINTER;
NEXTNAME:NAMEPOINTER;
C:ASCIICODE;
H:0..HASHSIZE;
BLINK:ARRAY[0..MAXNAMES]OF SIXTEENBITS;
{225}CURDEPTH:EIGHTBITS;
CURBYTE:0..MAXBYTES;
CURVAL:SIXTEENBITS;
{MAXSORTPTR:0..MAXSCRAPS;}{227}COLLATE:ARRAY[0..100]OF ASCIICODE;
{235}NEXTXREF,THISXREF:0..MAXREFS;{239}{TROUBLESHOOT:BOOLEAN;
DDT:SIXTEENBITS;
DD:SIXTEENBITS;
DEBUGCYCLE:INTEGER;
DEBUGSKIPPED:INTEGER;
TERMIN:TEXTFILE;}{28}
{PROCEDURE DEBUGHELP;
FORWARD;}{29}PROCEDURE ERROR;
VAR K,L:0..LONGBUFSIZE;
BEGIN{30}BEGIN IF CHANGING THEN WRITE(TERMOUT,'. (change file ')ELSE
WRITE(TERMOUT,'. (');
WRITELN(TERMOUT,'l.',LINE:0,')');
IF LOC>=LIMIT THEN L:=LIMIT ELSE L:=LOC;
FOR K:=1 TO L DO IF BUFFER[K-1]=9 THEN WRITE(TERMOUT,' ')ELSE WRITE(
TERMOUT,XCHR[BUFFER[K-1]]);
WRITELN(TERMOUT);
FOR K:=1 TO L DO WRITE(TERMOUT,' ');
FOR K:=L+1 TO LIMIT DO WRITE(TERMOUT,XCHR[BUFFER[K-1]]);
IF BUFFER[LIMIT]=124 THEN WRITE(TERMOUT,XCHR[124]);
WRITE(TERMOUT,' ');
END;
BREAK(TERMOUT);{DEBUGSKIPPED:=DEBUGCYCLE;
DEBUGHELP;}END;
{31}PROCEDURE QUIT;
BEGIN GOTO 9999;
END;
PROCEDURE INITIALIZE;
VAR{14}I:0..127;{50}H:0..HASHSIZE;
BEGIN{12}XCHR[32]:=' ';XCHR[33]:='!';
XCHR[34]:='"';XCHR[35]:='#';XCHR[36]:='$';XCHR[37]:='%';XCHR[38]:='&';
XCHR[39]:='''';XCHR[40]:='(';XCHR[41]:=')';XCHR[42]:='*';XCHR[43]:='+';
XCHR[44]:=',';XCHR[45]:='-';XCHR[46]:='.';XCHR[47]:='/';XCHR[48]:='0';
XCHR[49]:='1';XCHR[50]:='2';XCHR[51]:='3';XCHR[52]:='4';XCHR[53]:='5';
XCHR[54]:='6';XCHR[55]:='7';XCHR[56]:='8';XCHR[57]:='9';XCHR[58]:=':';
XCHR[59]:=';';XCHR[60]:='<';XCHR[61]:='=';XCHR[62]:='>';XCHR[63]:='?';
XCHR[64]:='@';XCHR[65]:='A';XCHR[66]:='B';XCHR[67]:='C';XCHR[68]:='D';
XCHR[69]:='E';XCHR[70]:='F';XCHR[71]:='G';XCHR[72]:='H';XCHR[73]:='I';
XCHR[74]:='J';XCHR[75]:='K';XCHR[76]:='L';XCHR[77]:='M';XCHR[78]:='N';
XCHR[79]:='O';XCHR[80]:='P';XCHR[81]:='Q';XCHR[82]:='R';XCHR[83]:='S';
XCHR[84]:='T';XCHR[85]:='U';XCHR[86]:='V';XCHR[87]:='W';XCHR[88]:='X';
XCHR[89]:='Y';XCHR[90]:='Z';XCHR[91]:='[';XCHR[92]:='\';XCHR[93]:=']';
XCHR[94]:='ā';XCHR[95]:='_';XCHR[96]:='`';XCHR[97]:='a';XCHR[98]:='b';
XCHR[99]:='c';XCHR[100]:='d';XCHR[101]:='e';XCHR[102]:='f';
XCHR[103]:='g';XCHR[104]:='h';XCHR[105]:='i';XCHR[106]:='j';
XCHR[107]:='k';XCHR[108]:='l';XCHR[109]:='m';XCHR[110]:='n';
XCHR[111]:='o';XCHR[112]:='p';XCHR[113]:='q';XCHR[114]:='r';
XCHR[115]:='s';XCHR[116]:='t';XCHR[117]:='u';XCHR[118]:='v';
XCHR[119]:='w';XCHR[120]:='x';XCHR[121]:='y';XCHR[122]:='z';
XCHR[123]:='{';XCHR[124]:='|';XCHR[125]:='}';XCHR[126]:='~';
XCHR[0]:=' ';XCHR[127]:=' ';
{15}FOR I:=1 TO 31 DO XCHR[I]:=' ';
{16}FOR I:=0 TO 127 DO XORD[CHR(I)]:=32;
FOR I:=1 TO 126 DO XORD[XCHR[I]]:=I;{19}REWRITE(TERMOUT,'TTY:');
{24}REWRITE(TEXFILE);{38}NAMEPTR:=1;
BYTEPTR:=1;
BYTESTART[0]:=1;
BYTESTART[1]:=1;{40}ILK[0]:=0;{43}XREFPTR:=0;
XREFSWITCH:=0;
MODXREFSWITC:=0;
XMEM[0].NUMFIELD:=0;{48}TOKPTR:=1;
TEXTPTR:=1;
TOKSTART[0]:=1;
TOKSTART[1]:=1;{MAXTOKPTR:=1;
MAXTXTPTR:=1;
}{51}FOR H:=0 TO HASHSIZE-1 DO HASH[H]:=0;{91}MODTEXT[0]:=32;
{112}OUTPTR:=1;
OUTLINE:=1;
OUTBUF[1]:=114;
WRITE(TEXFILE,'\input webhd');
{114}OUTBUF[0]:=92;{133}SCRAPBASE:=1;
SCRAPPTR:=0;{MAXSCRPTR:=0;
}{190}{MAXSTACKPTR:=0;}{226}{MAXSORTPTR:=0;}{228}COLLATE[0]:=0;
COLLATE[1]:=32;
FOR C:=1 TO 31 DO COLLATE[C+1]:=C;
FOR C:=33 TO 47 DO COLLATE[C]:=C;
FOR C:=58 TO 64 DO COLLATE[C-10]:=C;
FOR C:=91 TO 94 DO COLLATE[C-36]:=C;
COLLATE[59]:=96;
FOR C:=123 TO 126 DO COLLATE[C-63]:=C;
COLLATE[64]:=95;
FOR C:=97 TO 122 DO COLLATE[C-32]:=C;
FOR C:=48 TO 57 DO COLLATE[C+43]:=C;{240}{TROUBLESHOOT:=TRUE;
DEBUGCYCLE:=1;
DEBUGSKIPPED:=0;
TRACING:=0;
TROUBLESHOOT:=FALSE;
DEBUGCYCLE:=99999;
RESET(TERMIN,'TTY:','/I');}END;
{22}PROCEDURE OPENINPUT;
BEGIN RESET(WEBFILE);
RESET(CHANGEFILE);
END;
{26}FUNCTION INPUTLN(VAR F:TEXTFILE):BOOLEAN;
BEGIN LIMIT:=0;
IF EOF(F)THEN INPUTLN:=FALSE ELSE BEGIN WHILE NOT EOLN(F)DO BEGIN BUFFER
[LIMIT]:=XORD[Fā];
GET(F);
LIMIT:=LIMIT+1;
IF LIMIT=BUFSIZE THEN BEGIN WHILE NOT EOLN(F)DO GET(F);
LIMIT:=LIMIT-1;
BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Input line too long');
END;
ERROR;
END;
END;
READLN(F);
INPUTLN:=TRUE;
END;
END;
{41}PROCEDURE PRINTID(P:NAMEPOINTER);
VAR K:0..MAXBYTES;
BEGIN IF P>=NAMEPTR THEN WRITE(TERMOUT,'IMPOSSIBLE')ELSE FOR K:=
BYTESTART[P]TO BYTESTART[P+1]-1 DO WRITE(TERMOUT,XCHR[BYTEMEM[K]]);
END;
{44}PROCEDURE NEWXREF(P:NAMEPOINTER);
LABEL 10;
VAR Q:0..MAXREFS;
M,N:SIXTEENBITS;
BEGIN IF((ILK[P]>3)OR(BYTESTART[P]+1=BYTESTART[P+1]))AND(XREFSWITCH=0)
THEN GOTO 10;
M:=MODULECOUNT+XREFSWITCH;
XREFSWITCH:=0;
Q:=XREF[P];
IF Q>0 THEN BEGIN N:=XMEM[Q].NUMFIELD;
IF(N=M)OR(N=M+10240)THEN GOTO 10 ELSE IF M=N+10240 THEN BEGIN XMEM[Q].
NUMFIELD:=M;
GOTO 10;
END;
END;
IF XREFPTR=MAXREFS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','cross reference',' capacity exceeded');
ERROR;
QUIT;
END ELSE BEGIN XREFPTR:=XREFPTR+1;
XMEM[XREFPTR].NUMFIELD:=M;
END;
XMEM[XREFPTR].XLINKFIELD:=Q;
XREF[P]:=XREFPTR;
10:END;
{45}PROCEDURE NEWMODXREF(P:NAMEPOINTER);
VAR Q,R:0..MAXREFS;
BEGIN Q:=XREF[P];
R:=0;
IF Q>0 THEN BEGIN IF MODXREFSWITC=0 THEN WHILE XMEM[Q].NUMFIELD>=10240
DO BEGIN R:=Q;
Q:=XMEM[Q].XLINKFIELD;
END ELSE IF XMEM[Q].NUMFIELD>=10240 THEN BEGIN R:=Q;
Q:=XMEM[Q].XLINKFIELD;
END;
END;
IF XREFPTR=MAXREFS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','cross reference',' capacity exceeded');
ERROR;
QUIT;
END ELSE BEGIN XREFPTR:=XREFPTR+1;
XMEM[XREFPTR].NUMFIELD:=MODULECOUNT+MODXREFSWITC;
END;
XMEM[XREFPTR].XLINKFIELD:=Q;
MODXREFSWITC:=0;
IF R=0 THEN XREF[P]:=XREFPTR ELSE XMEM[R].XLINKFIELD:=XREFPTR;
END;
{52}FUNCTION IDLOOKUP(T:EIGHTBITS):NAMEPOINTER;
LABEL 31;
VAR I:0..LONGBUFSIZE;
H:0..HASHSIZE;
K:0..MAXBYTES;
L:0..LONGBUFSIZE;
P,Q:NAMEPOINTER;
BEGIN L:=IDLOC-IDFIRST;{53}H:=BUFFER[IDFIRST];
I:=IDFIRST+1;
WHILE I<IDLOC DO BEGIN H:=(H+H+BUFFER[I])MOD HASHSIZE;
I:=I+1;
END;{54}P:=HASH[H];
WHILE P<>0 DO BEGIN IF(BYTESTART[P+1]-BYTESTART[P]=L)AND((ILK[P]=T)OR((T
=0)AND(ILK[P]>3)))THEN{55}BEGIN I:=IDFIRST;
K:=BYTESTART[P];
WHILE(I<IDLOC)AND(BUFFER[I]=BYTEMEM[K])DO BEGIN I:=I+1;
K:=K+1;
END;
IF I=IDLOC THEN GOTO 31;
END;
P:=LINK[P];
END;
P:=NAMEPTR;
LINK[P]:=HASH[H];
HASH[H]:=P;
31:;
IF P=NAMEPTR THEN{56}BEGIN IF BYTEPTR+L>MAXBYTES THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Sorry, ','byte memory',' capacity exceeded');
ERROR;
QUIT;
END;
IF NAMEPTR=MAXNAMES THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','name',' capacity exceeded');
ERROR;
QUIT;
END;
I:=IDFIRST;
K:=BYTEPTR;
WHILE I<IDLOC DO BEGIN BYTEMEM[K]:=BUFFER[I];
K:=K+1;
I:=I+1;
END;
BYTEPTR:=K;
NAMEPTR:=NAMEPTR+1;
BYTESTART[NAMEPTR]:=K;
ILK[P]:=T;
XREF[P]:=0;
END;
IDLOOKUP:=P;
END;
{60}FUNCTION MODLOOKUP(L:SIXTEENBITS):NAMEPOINTER;
LABEL 31;
VAR C:(LESS,EQUAL,GREATER,PREFIX,EXTENSION);
J:0..LONGESTNAME;
K:0..MAXBYTES;
P:NAMEPOINTER;
Q:NAMEPOINTER;
BEGIN C:=GREATER;
Q:=0;
P:=ILK[0];
WHILE P<>0 DO BEGIN{62}BEGIN K:=BYTESTART[P];
C:=EQUAL;
J:=1;
WHILE(K<BYTESTART[P+1])AND(J<=L)AND(MODTEXT[J]=BYTEMEM[K])DO BEGIN K:=K
+1;
J:=J+1;
END;
IF K=BYTESTART[P+1]THEN IF J>L THEN C:=EQUAL ELSE C:=EXTENSION ELSE IF J
>L THEN C:=PREFIX ELSE IF MODTEXT[J]<BYTEMEM[K]THEN C:=LESS ELSE C:=
GREATER;
END;
Q:=P;
IF C=LESS THEN P:=LINK[Q]ELSE IF C=GREATER THEN P:=ILK[Q]ELSE GOTO 31;
END;{61}IF BYTEPTR+L>MAXBYTES THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','byte memory',' capacity exceeded');
ERROR;
QUIT;
END;
IF NAMEPTR=MAXNAMES THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','name',' capacity exceeded');
ERROR;
QUIT;
END;
P:=NAMEPTR;
IF C=LESS THEN LINK[Q]:=P ELSE ILK[Q]:=P;
LINK[P]:=0;
ILK[P]:=0;
XREF[P]:=0;
C:=EQUAL;
FOR J:=1 TO L DO BYTEMEM[BYTEPTR+J-1]:=MODTEXT[J];
BYTEPTR:=BYTEPTR+L;
NAMEPTR:=NAMEPTR+1;
BYTESTART[NAMEPTR]:=BYTEPTR;
31:IF C<>EQUAL THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Incompatible module names');
ERROR;
END;
END;
P:=0;
END;
MODLOOKUP:=P;
END;
{63}FUNCTION PREFIXLOOKUP(L:SIXTEENBITS):NAMEPOINTER;
VAR C:(LESS,EQUAL,GREATER,PREFIX,EXTENSION);
COUNT:0..MAXNAMES;
J:0..LONGESTNAME;
K:0..MAXBYTES;
P:NAMEPOINTER;
Q:NAMEPOINTER;
R:NAMEPOINTER;
BEGIN Q:=0;
P:=ILK[0];
COUNT:=0;
R:=0;
WHILE P<>0 DO BEGIN{62}BEGIN K:=BYTESTART[P];
C:=EQUAL;
J:=1;
WHILE(K<BYTESTART[P+1])AND(J<=L)AND(MODTEXT[J]=BYTEMEM[K])DO BEGIN K:=K
+1;
J:=J+1;
END;
IF K=BYTESTART[P+1]THEN IF J>L THEN C:=EQUAL ELSE C:=EXTENSION ELSE IF J
>L THEN C:=PREFIX ELSE IF MODTEXT[J]<BYTEMEM[K]THEN C:=LESS ELSE C:=
GREATER;
END;
IF C=LESS THEN P:=LINK[P]ELSE IF C=GREATER THEN P:=ILK[P]ELSE BEGIN R:=P
;
COUNT:=COUNT+1;
Q:=ILK[P];
P:=LINK[P];
END;
IF P=0 THEN BEGIN P:=Q;
Q:=0;
END;
END;
IF COUNT<>1 THEN IF COUNT=0 THEN BEGIN IF NOT PHASEONE THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! Name does not match');
ERROR;
END;
END ELSE BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Ambiguous prefix');
ERROR;
END;
END;
PREFIXLOOKUP:=R;
END;
{67}PROCEDURE PRIMETHECHAN;
LABEL 20;
VAR K:0..BUFSIZE;
BEGIN 20:IF INPUTLN(CHANGEFILE)THEN BEGIN IF LIMIT=0 THEN GOTO 20;
FOR K:=0 TO LIMIT DO CHANGEBUFFER[K]:=BUFFER[K];
CHANGELIMIT:=LIMIT;
END ELSE BEGIN CHANGEBUFFER[0]:=0;
CHANGELIMIT:=0;
END;
END;
{68}PROCEDURE CHECKCHANGE;
LABEL 10;
VAR K:0..BUFSIZE;
BEGIN FOR K:=1 TO LIMIT-1 DO IF BUFFER[K]<>CHANGEBUFFER[K]THEN GOTO 10;
CHANGING:=TRUE;
TEMPLINE:=OTHERLINE;
OTHERLINE:=LINE;
LINE:=TEMPLINE;
10:END;{69}PROCEDURE RESETINPUT;
BEGIN OPENINPUT;
LINE:=1;
CHANGING:=FALSE;
PRIMETHECHAN;
OTHERLINE:=LINE;
LINE:=0;
LIMIT:=0;
LOC:=1;
BUFFER[0]:=32;
INPUTHASENDE:=FALSE;
END;{70}PROCEDURE GETLINE;
LABEL 10,30,31;
BEGIN LINE:=LINE+1;
IF CHANGING THEN{72}BEGIN IF LIMIT>1 THEN IF(BUFFER[LIMIT-2]=64)AND((
BUFFER[LIMIT-1]=122)OR(BUFFER[LIMIT-1]=90))THEN{73}BEGIN CHANGING:=FALSE
;
PRIMETHECHAN;
TEMPLINE:=OTHERLINE;
OTHERLINE:=LINE;
LINE:=TEMPLINE;
{74}WHILE TRUE DO BEGIN LOC:=0;
LINE:=LINE+1;
IF INPUTLN(WEBFILE)THEN{75}BEGIN BUFFER[LIMIT+1]:=64;
WHILE TRUE DO BEGIN IF BUFFER[LOC]=64 THEN IF LOC<LIMIT THEN BEGIN LOC:=
LOC+2;
IF(BUFFER[LOC-1]=32)OR(BUFFER[LOC-1]=9)OR(BUFFER[LOC-1]=42)THEN BEGIN
LOC:=LOC-2;
GOTO 31;
END ELSE IF(BUFFER[LOC-1]=122)OR(BUFFER[LOC-1]=90)THEN GOTO 31;
END ELSE GOTO 30 ELSE LOC:=LOC+1;
END;
30:END ELSE BEGIN INPUTHASENDE:=TRUE;
GOTO 31;
END;
END;
31:;
BUFFER[LIMIT]:=32;
IF(BUFFER[0]=CHANGEBUFFER[0])AND(LIMIT=CHANGELIMIT)THEN CHECKCHANGE;
GOTO 10;
END;
IF NOT INPUTLN(CHANGEFILE)THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! Change file ended without @z');
ERROR;
END;
END;
BUFFER[0]:=64;
BUFFER[1]:=122;
LIMIT:=2;
END;
END ELSE{71}BEGIN IF NOT INPUTLN(WEBFILE)THEN INPUTHASENDE:=TRUE ELSE IF
(BUFFER[0]=CHANGEBUFFER[0])AND(LIMIT=CHANGELIMIT)THEN CHECKCHANGE;
END;
LOC:=0;
BUFFER[LIMIT]:=32;
10:END;
{78}FUNCTION CONTROLCODE(C:ASCIICODE):EIGHTBITS;
BEGIN CASE C OF 64:CONTROLCODE:=64;
39:CONTROLCODE:=12;
32,9,42:CONTROLCODE:=146;
68,100:CONTROLCODE:=142;
70,102:CONTROLCODE:=141;
123:CONTROLCODE:=9;
125:CONTROLCODE:=10;
80,112:CONTROLCODE:=143;
38:CONTROLCODE:=127;
60:CONTROLCODE:=144;
62:BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Extra @>');
ERROR;
END;
END;
CONTROLCODE:=0;
END;
84,116:CONTROLCODE:=134;
90,122:CONTROLCODE:=145;
33:CONTROLCODE:=126;
63:CONTROLCODE:=125;
94:CONTROLCODE:=131;
58:CONTROLCODE:=132;
46:CONTROLCODE:=133;
44:CONTROLCODE:=135;
124:CONTROLCODE:=136;
47:CONTROLCODE:=137;
35:CONTROLCODE:=138;
43:CONTROLCODE:=139;
59:CONTROLCODE:=140;{79}{48,49,50:BEGIN TRACING:=C-48;
CONTROLCODE:=0;
END;}OTHERS:BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Unknown control code');
ERROR;
END;
END;
CONTROLCODE:=0;
END END;
END;{80}PROCEDURE SKIPLIMBO;
LABEL 10;
VAR C:ASCIICODE;
BEGIN WHILE TRUE DO IF LOC>LIMIT THEN BEGIN GETLINE;
IF INPUTHASENDE THEN GOTO 10;
END ELSE BEGIN BUFFER[LIMIT+1]:=64;
WHILE BUFFER[LOC]<>64 DO LOC:=LOC+1;
IF LOC<=LIMIT THEN BEGIN LOC:=LOC+2;
C:=BUFFER[LOC-1];
IF(C=32)OR(C=9)OR(C=42)THEN GOTO 10;
END;
END;
10:END;
{81}FUNCTION SKIPTEX:EIGHTBITS;
LABEL 30;
VAR C:EIGHTBITS;
BEGIN WHILE TRUE DO BEGIN IF LOC>LIMIT THEN BEGIN GETLINE;
IF INPUTHASENDE THEN BEGIN C:=145;
GOTO 30;
END;
END;
BUFFER[LIMIT+1]:=64;
REPEAT C:=BUFFER[LOC];
LOC:=LOC+1;
IF C=124 THEN GOTO 30;
UNTIL C=64;
IF LOC<=LIMIT THEN BEGIN C:=CONTROLCODE(BUFFER[LOC]);
LOC:=LOC+1;
GOTO 30;
END;
END;
30:SKIPTEX:=C;
END;
{82}FUNCTION SKIPCOMMENT(BAL:EIGHTBITS):EIGHTBITS;
LABEL 30;
VAR C:ASCIICODE;
BEGIN WHILE TRUE DO BEGIN IF LOC>LIMIT THEN BEGIN GETLINE;
IF INPUTHASENDE THEN BEGIN BAL:=0;
GOTO 30;
END;
END;
C:=BUFFER[LOC];
LOC:=LOC+1;
IF C=124 THEN GOTO 30;{83}IF C=64 THEN BEGIN C:=BUFFER[LOC];
IF(C<>32)AND(C<>9)AND(C<>42)THEN LOC:=LOC+1 ELSE BEGIN LOC:=LOC-1;
BAL:=0;
GOTO 30;
END END ELSE IF(C=92)AND(BUFFER[LOC]<>64)THEN LOC:=LOC+1 ELSE IF C=123
THEN BAL:=BAL+1 ELSE IF C=125 THEN BEGIN BAL:=BAL-1;
IF BAL=0 THEN GOTO 30;
END;
END;
30:SKIPCOMMENT:=BAL;
END;
{85}FUNCTION GETNEXT:EIGHTBITS;
LABEL 20,30,31;
VAR C:EIGHTBITS;
D:EIGHTBITS;
J,K:0..LONGESTNAME;
BEGIN 20:IF LOC>LIMIT THEN BEGIN GETLINE;
IF INPUTHASENDE THEN BEGIN C:=145;
GOTO 31;
END;
END;
C:=BUFFER[LOC];
LOC:=LOC+1;
CASE C OF 65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85
,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111
,112,113,114,115,116,117,118,119,120,121,122:{87}BEGIN IF((C=69)OR(C=101
))AND(LOC>1)THEN IF(BUFFER[LOC-2]<=57)AND(BUFFER[LOC-2]>=48)THEN C:=128;
IF C<>128 THEN BEGIN LOC:=LOC-1;
IDFIRST:=LOC;
REPEAT LOC:=LOC+1;
D:=BUFFER[LOC];
UNTIL((D<48)OR((D>57)AND(D<65))OR((D>90)AND(D<97))OR(D>122))AND(D<>95);
C:=130;
IDLOC:=LOC;
END;
END;
39,34:{88}BEGIN IDFIRST:=LOC-1;
REPEAT D:=BUFFER[LOC];
LOC:=LOC+1;
IF LOC>LIMIT THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT
);
WRITE(TERMOUT,'! String constant didn''t end');
ERROR;
END;
END;
LOC:=LIMIT;
D:=C;
END;
UNTIL D=C;
IDLOC:=LOC;
C:=129;
END;
64:{89}BEGIN C:=CONTROLCODE(BUFFER[LOC]);
LOC:=LOC+1;
IF C=126 THEN BEGIN XREFSWITCH:=10240;
GOTO 20;
END ELSE IF C=125 THEN BEGIN XREFSWITCH:=0;
GOTO 20;
END ELSE IF(C<=134)AND(C>=131)THEN{95}BEGIN IDFIRST:=LOC;
BUFFER[LIMIT+1]:=64;
WHILE BUFFER[LOC]<>64 DO LOC:=LOC+1;
IDLOC:=LOC;
IF LOC>LIMIT THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT
);
WRITE(TERMOUT,'! Control text didn''t end');
ERROR;
END;
END;
LOC:=LIMIT;
END ELSE BEGIN LOC:=LOC+2;
IF BUFFER[LOC-1]<>62 THEN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Control codes are forbidden in control text');
ERROR;
END;
END;
END;
END ELSE IF C=144 THEN{90}BEGIN{92}K:=0;
WHILE TRUE DO BEGIN IF LOC>LIMIT THEN BEGIN GETLINE;
IF INPUTHASENDE THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Input ended in module name');
ERROR;
END;
END;
LOC:=1;
GOTO 30;
END;
END;
D:=BUFFER[LOC];
{93}IF D=64 THEN BEGIN D:=BUFFER[LOC+1];
IF D=62 THEN BEGIN LOC:=LOC+2;
GOTO 30;
END;
IF(D=32)OR(D=9)OR(D=42)THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! Module name didn''t end');
ERROR;
END;
END;
GOTO 30;
END;
K:=K+1;
MODTEXT[K]:=64;
LOC:=LOC+1;
END;
LOC:=LOC+1;
IF K<LONGESTNAME-1 THEN K:=K+1;
IF(D=32)OR(D=9)THEN BEGIN D:=32;
IF MODTEXT[K-1]=32 THEN K:=K-1;
END;
MODTEXT[K]:=D;
END;
30:{94}IF K>=LONGESTNAME-2 THEN BEGIN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Module name too long: ');
END;
FOR J:=1 TO 25 DO WRITE(TERMOUT,XCHR[MODTEXT[J]]);
WRITE(TERMOUT,'...');
END;
IF(MODTEXT[K]=32)AND(K>0)THEN K:=K-1;
IF K>3 THEN BEGIN IF(MODTEXT[K]=46)AND(MODTEXT[K-1]=46)AND(MODTEXT[K-2]=
46)THEN CURMODULE:=PREFIXLOOKUP(K-3)ELSE CURMODULE:=MODLOOKUP(K);
END ELSE CURMODULE:=MODLOOKUP(K);
END;
END;
{86}46:IF BUFFER[LOC]=46 THEN BEGIN C:=32;
LOC:=LOC+1;
END ELSE IF BUFFER[LOC]=41 THEN BEGIN C:=93;
LOC:=LOC+1;
END;
58:IF BUFFER[LOC]=61 THEN BEGIN C:=24;
LOC:=LOC+1;
END;
61:IF BUFFER[LOC]=61 THEN BEGIN C:=30;
LOC:=LOC+1;
END;
62:IF BUFFER[LOC]=61 THEN BEGIN C:=29;
LOC:=LOC+1;
END;
60:IF BUFFER[LOC]=61 THEN BEGIN C:=28;
LOC:=LOC+1;
END ELSE IF BUFFER[LOC]=62 THEN BEGIN C:=26;
LOC:=LOC+1;
END;
40:IF BUFFER[LOC]=42 THEN BEGIN C:=9;
LOC:=LOC+1;
END ELSE IF BUFFER[LOC]=46 THEN BEGIN C:=91;
LOC:=LOC+1;
END;
42:IF BUFFER[LOC]=41 THEN BEGIN C:=10;
LOC:=LOC+1;
END;
32,9:GOTO 20;
OTHERS:END;
31:{IF TROUBLESHOOT THEN DEBUGHELP;}GETNEXT:=C;
END;
{99}PROCEDURE PASCALXREF;
LABEL 10;
VAR P:NAMEPOINTER;
BEGIN WHILE NEXTCONTROL<141 DO BEGIN IF(NEXTCONTROL>=130)AND(NEXTCONTROL
<=133)THEN BEGIN P:=IDLOOKUP(NEXTCONTROL-130);
NEWXREF(P);
IF(ILK[P]=17)OR(ILK[P]=22)THEN XREFSWITCH:=10240;
END;
NEXTCONTROL:=GETNEXT;
IF(NEXTCONTROL=124)OR(NEXTCONTROL=123)THEN GOTO 10;
END;
10:END;{100}PROCEDURE OUTERXREF;
VAR BAL:EIGHTBITS;
BEGIN WHILE NEXTCONTROL<141 DO IF NEXTCONTROL<>123 THEN PASCALXREF ELSE
BEGIN BAL:=SKIPCOMMENT(1);
NEXTCONTROL:=124;
WHILE BAL>0 DO BEGIN PASCALXREF;
IF NEXTCONTROL=124 THEN BAL:=SKIPCOMMENT(BAL)ELSE BAL:=0;
END;
END;
END;
{107}PROCEDURE MODCHECK(P:NAMEPOINTER);
BEGIN IF P>0 THEN BEGIN MODCHECK(LINK[P]);
CURXREF:=XREF[P];
IF XMEM[CURXREF].NUMFIELD<10240 THEN BEGIN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Never defined: <');
END;
PRINTID(P);
WRITE(TERMOUT,'>');
END;
WHILE XMEM[CURXREF].NUMFIELD>=10240 DO CURXREF:=XMEM[CURXREF].XLINKFIELD
;
IF CURXREF=0 THEN BEGIN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Never used: <');
END;
PRINTID(P);
WRITE(TERMOUT,'>');
END;
MODCHECK(ILK[P]);
END;
END;{110}PROCEDURE FLUSHBUFFER(B:EIGHTBITS);
VAR K:0..LINELENGTH;
BEGIN IF(OUTBUF[B]=32)AND(B>0)THEN B:=B-1;
FOR K:=1 TO B DO WRITE(TEXFILE,XCHR[OUTBUF[K]]);
WRITELN(TEXFILE);
OUTLINE:=OUTLINE+1;
IF B<OUTPTR THEN IF OUTBUF[B+1]=32 THEN B:=B+1;
IF B<OUTPTR THEN FOR K:=B+1 TO OUTPTR DO OUTBUF[K-B]:=OUTBUF[K];
OUTPTR:=OUTPTR-B;
END;{111}PROCEDURE FINISHLINE;
LABEL 10;
VAR K:0..BUFSIZE;
BEGIN IF OUTPTR>0 THEN FLUSHBUFFER(OUTPTR)ELSE BEGIN FOR K:=0 TO LIMIT
DO IF(BUFFER[K]<>32)AND(BUFFER[K]<>9)THEN GOTO 10;
FLUSHBUFFER(0);
END;
10:END;{115}PROCEDURE BREAKOUT;
VAR K:0..LINELENGTH;
C,D:ASCIICODE;
BEGIN K:=OUTPTR;
D:=OUTBUF[K];
WHILE D<>32 DO BEGIN K:=K-1;
C:=OUTBUF[K];
IF C=92 THEN IF K=0 THEN{116}BEGIN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Line had to be broken (output l.',OUTLINE:0);
END;
WRITELN(TERMOUT,'):');
FOR K:=1 TO OUTPTR DO WRITE(TERMOUT,XCHR[OUTBUF[K]]);
WRITELN(TERMOUT);
K:=OUTPTR;
C:=32;
END ELSE IF(((D<65)OR((D>90)AND(D<97))OR(D>122))AND(OUTBUF[K-1]<>92))
THEN BEGIN K:=K+1;
C:=32;
END;
D:=C;
END;
FLUSHBUFFER(K);
END;
{118}PROCEDURE OUTVAL(V:SIXTEENBITS);
VAR K:0..5;
BEGIN K:=0;
REPEAT DIG[K]:=V MOD 10;
V:=V DIV 10;
K:=K+1;
UNTIL V=0;
REPEAT K:=K-1;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=DIG[K]+48;
END;
UNTIL K=0;
END;
{119}PROCEDURE OUTNAME(P:NAMEPOINTER);
VAR K:0..MAXBYTES;
BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=123;
END;
FOR K:=BYTESTART[P]TO BYTESTART[P+1]-1 DO BEGIN IF BYTEMEM[K]=95 THEN
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=BYTEMEM[K];
END;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=125;
END;
END;{120}PROCEDURE COPYLIMBO;
LABEL 10;
VAR C:ASCIICODE;
BEGIN WHILE TRUE DO IF LOC>LIMIT THEN BEGIN FINISHLINE;
GETLINE;
IF INPUTHASENDE THEN GOTO 10;
END ELSE BEGIN BUFFER[LIMIT+1]:=64;
{121}WHILE BUFFER[LOC]<>64 DO BEGIN BEGIN IF OUTPTR=LINELENGTH THEN
BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=BUFFER[LOC];
END;
LOC:=LOC+1;
END;
IF LOC<=LIMIT THEN BEGIN LOC:=LOC+2;
C:=BUFFER[LOC-1];
IF(C=32)OR(C=9)OR(C=42)THEN GOTO 10;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=64;
END;
IF C<>64 THEN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Double @ required outside of modules');
ERROR;
END;
END;
END;
END;
10:END;
{122}FUNCTION COPYTEX:EIGHTBITS;
LABEL 30;
VAR C:EIGHTBITS;
BEGIN WHILE TRUE DO BEGIN IF LOC>LIMIT THEN BEGIN FINISHLINE;
GETLINE;
IF INPUTHASENDE THEN BEGIN C:=145;
GOTO 30;
END;
END;
BUFFER[LIMIT+1]:=64;
{123}REPEAT C:=BUFFER[LOC];
LOC:=LOC+1;
IF C=124 THEN GOTO 30;
IF C<>64 THEN BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=C;
END;
IF(OUTPTR=1)AND((C=32)OR(C=9))THEN OUTPTR:=OUTPTR-1;
END;
UNTIL C=64;
IF LOC<=LIMIT THEN BEGIN C:=CONTROLCODE(BUFFER[LOC]);
LOC:=LOC+1;
GOTO 30;
END;
END;
30:COPYTEX:=C;
END;
{124}FUNCTION COPYCOMMENT(BAL:EIGHTBITS):EIGHTBITS;
LABEL 30;
VAR C:ASCIICODE;
BEGIN WHILE TRUE DO BEGIN IF LOC>LIMIT THEN BEGIN GETLINE;
IF INPUTHASENDE THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Input ended in mid-comment');
ERROR;
END;
END;
LOC:=1;{126}BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
END;
REPEAT BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
END;
BAL:=BAL-1;
UNTIL BAL=0;
GOTO 30;
;
END;
END;
C:=BUFFER[LOC];
LOC:=LOC+1;
IF C=124 THEN GOTO 30;
BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=C;
TOKPTR:=TOKPTR+1;
END;
{125}IF C=64 THEN BEGIN LOC:=LOC+1;
IF BUFFER[LOC-1]<>64 THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN
(TERMOUT);
WRITE(TERMOUT,'! Illegal use of @ in comment');
ERROR;
END;
END;
LOC:=LOC-2;
TOKPTR:=TOKPTR-1;
{126}BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
END;
REPEAT BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
END;
BAL:=BAL-1;
UNTIL BAL=0;
GOTO 30;
;
END;
END ELSE IF(C=92)AND(BUFFER[LOC]<>64)THEN BEGIN BEGIN IF TOKPTR+2>
MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=BUFFER[LOC];
TOKPTR:=TOKPTR+1;
END;
LOC:=LOC+1;
END ELSE IF C=123 THEN BAL:=BAL+1 ELSE IF C=125 THEN BEGIN BAL:=BAL-1;
IF BAL=0 THEN GOTO 30;
END;
END;
30:COPYCOMMENT:=BAL;
END;
{128}{PROCEDURE PRINTCAT(C:EIGHTBITS);
BEGIN CASE C OF 1:WRITE(TERMOUT,'simp');
2:WRITE(TERMOUT,'math');
3:WRITE(TERMOUT,'intro');
4:WRITE(TERMOUT,'open');
5:WRITE(TERMOUT,'beginning');
6:WRITE(TERMOUT,'close');
7:WRITE(TERMOUT,'alpha');
8:WRITE(TERMOUT,'omega');
9:WRITE(TERMOUT,'semi');
10:WRITE(TERMOUT,'terminator');
11:WRITE(TERMOUT,'stmt');
12:WRITE(TERMOUT,'cond');
13:WRITE(TERMOUT,'clause');
14:WRITE(TERMOUT,'colon');
15:WRITE(TERMOUT,'exp');
16:WRITE(TERMOUT,'proc');
17:WRITE(TERMOUT,'casehead');
18:WRITE(TERMOUT,'recordhead');
19:WRITE(TERMOUT,'varhead');
20:WRITE(TERMOUT,'elsie');
21:WRITE(TERMOUT,'casey');
22:WRITE(TERMOUT,'module');
OTHERS:WRITE(TERMOUT,'UNKNOWN')END;
END;
}{134}{PROCEDURE PRINTTEXT(P:TEXTPOINTER);
VAR J:0..MAXTOKS;
R:0..10239;
BEGIN IF P>=TEXTPTR THEN WRITE(TERMOUT,'BAD')ELSE FOR J:=TOKSTART[P]TO
TOKSTART[P+1]-1 DO BEGIN R:=TOKMEM[J]MOD 10240;
CASE TOKMEM[J]DIV 10240 OF 1:BEGIN WRITE(TERMOUT,'\\',XCHR[123]);
PRINTID(R);
WRITE(TERMOUT,XCHR[125]);
END;
2:BEGIN WRITE(TERMOUT,'\&',XCHR[123]);
PRINTID(R);
WRITE(TERMOUT,XCHR[125]);
END;
3:BEGIN WRITE(TERMOUT,'<');
PRINTID(R);
WRITE(TERMOUT,'>');
END;
4:WRITE(TERMOUT,'[[',R:0,']]');
5:WRITE(TERMOUT,'|[[',R:0,']]|');
OTHERS:[135]CASE R OF 131:WRITE(TERMOUT,'\mathbin',XCHR[123]);
132:WRITE(TERMOUT,'\mathrel',XCHR[123]);
133:WRITE(TERMOUT,'\mathop',XCHR[123]);
134:WRITE(TERMOUT,'[ccancel]');
135:WRITE(TERMOUT,'[cancel]');
136:WRITE(TERMOUT,'[indent]');
137:WRITE(TERMOUT,'[outdent]');
139:WRITE(TERMOUT,'[backup]');
138:WRITE(TERMOUT,'[opt]');
140:WRITE(TERMOUT,'[break]');
141:WRITE(TERMOUT,'[force]');
142:WRITE(TERMOUT,'[fforce]');
143:WRITE(TERMOUT,'[quit]');
OTHERS:WRITE(TERMOUT,XCHR[R])END END;
END;
END;}{160}PROCEDURE RED(J:SIXTEENBITS;
K:EIGHTBITS;
C:EIGHTBITS;
D:INTEGER);
VAR I:0..MAXSCRAPS;
BEGIN CAT[J]:=C;
TRANS[J]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
IF K>1 THEN BEGIN FOR I:=J+K TO LOPTR DO BEGIN CAT[I-K+1]:=CAT[I];
TRANS[I-K+1]:=TRANS[I];
END;
LOPTR:=LOPTR-K+1;
END;
{161}IF PP+D>=SCRAPBASE THEN PP:=PP+D ELSE PP:=SCRAPBASE;
END;
{162}PROCEDURE SQ(J:SIXTEENBITS;
K:EIGHTBITS;
C:EIGHTBITS;
D:INTEGER);
VAR I:0..MAXSCRAPS;
BEGIN IF K=1 THEN BEGIN CAT[J]:=C;
{161}IF PP+D>=SCRAPBASE THEN PP:=PP+D ELSE PP:=SCRAPBASE;
END ELSE BEGIN FOR I:=J TO J+K-1 DO BEGIN TOKMEM[TOKPTR]:=40960+TRANS[I]
;
TOKPTR:=TOKPTR+1;
END;
RED(J,K,C,D);
END;
END;
{166}{PROCEDURE PROD(N:EIGHTBITS);
VAR K:1..MAXSCRAPS;
BEGIN IF TRACING=2 THEN BEGIN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,N:0,':');
END;
FOR K:=SCRAPBASE TO LOPTR DO BEGIN IF K=PP THEN WRITE(TERMOUT,'*')ELSE
WRITE(TERMOUT,' ');
PRINTCAT(CAT[K]);
END;
IF HIPTR<=SCRAPPTR THEN WRITE(TERMOUT,'...');
END;
END;
}{167}{138}PROCEDURE SIXCASES;
LABEL 31;
BEGIN CASE CAT[PP]OF 7:{139}IF CAT[PP+1]=2 THEN BEGIN IF CAT[PP+2]=14
THEN BEGIN SQ(PP+1,2,2,0);{PROD(1)};
GOTO 31;
END ELSE IF CAT[PP+2]=8 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=136;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
RED(PP,3,13,-2);{PROD(2)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=8 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=136;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,13,-2);{PROD(3)};
GOTO 31;
END ELSE IF CAT[PP+1]=1 THEN BEGIN SQ(PP+1,1,2,0);{PROD(4)};
GOTO 31;
END;
5:{140}IF CAT[PP+1]=6 THEN BEGIN IF(CAT[PP+2]=10)OR(CAT[PP+2]=11)THEN
BEGIN SQ(PP,3,11,-2);{PROD(5)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,5,-1);
{PROD(6)};
GOTO 31;
END;
3:{147}IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=138;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=55;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,11,-2);
{PROD(17)};
GOTO 31;
END;
2:{148}IF CAT[PP+1]=6 THEN BEGIN TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
RED(PP,1,11,-2);{PROD(18)};
GOTO 31;
END ELSE IF CAT[PP+1]=14 THEN BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,3,-3);
{PROD(19)};
GOTO 31;
END ELSE IF CAT[PP+1]=2 THEN BEGIN SQ(PP,2,2,-1);
{PROD(20)};
GOTO 31;
END ELSE IF CAT[PP+1]=1 THEN BEGIN SQ(PP,2,2,-1);
{PROD(21)};
GOTO 31;
END ELSE IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=136;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
RED(PP,2,11,-2);{PROD(22)};
GOTO 31;
END ELSE IF CAT[PP+1]=10 THEN BEGIN TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,11,-2);{PROD(23)};
GOTO 31;
END;
4:{150}IF(CAT[PP+1]=17)AND(CAT[PP+2]=6)THEN BEGIN TOKMEM[TOKPTR]:=40960+
TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
RED(PP,3,2,-1);{PROD(26)};
GOTO 31;
END ELSE IF CAT[PP+1]=6 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=44;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,2,-1);{PROD(27)};
GOTO 31;
END ELSE IF CAT[PP+1]=2 THEN{151}BEGIN IF(CAT[PP+2]=17)AND(CAT[PP+3]=6)
THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+3];
TOKPTR:=TOKPTR+1;
RED(PP,4,2,-1);{PROD(28)};
GOTO 31;
END ELSE IF CAT[PP+2]=6 THEN BEGIN SQ(PP,3,2,-1);{PROD(29)};
GOTO 31;
END ELSE IF CAT[PP+2]=14 THEN BEGIN SQ(PP+1,2,2,0);{PROD(30)};
GOTO 31;
END ELSE IF CAT[PP+2]=16 THEN BEGIN IF CAT[PP+3]=3 THEN BEGIN TOKMEM[
TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=133;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
RED(PP+1,3,2,0);{PROD(31)};
GOTO 31;
END;
END ELSE IF CAT[PP+2]=9 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=44;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=138;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=53;
TOKPTR:=TOKPTR+1;
RED(PP+1,2,2,0);{PROD(32)};
GOTO 31;
END ELSE IF CAT[PP+2]=19 THEN BEGIN IF CAT[PP+3]=3 THEN BEGIN TOKMEM[
TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=133;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
RED(PP+1,3,2,0);{PROD(31)};
GOTO 31;
END;
END;
END ELSE IF CAT[PP+1]=16 THEN BEGIN IF CAT[PP+2]=3 THEN BEGIN TOKMEM[
TOKPTR]:=133;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
RED(PP+1,2,2,0);{PROD(34)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=1 THEN BEGIN SQ(PP+1,1,2,0);{PROD(35)};
GOTO 31;
END ELSE IF(CAT[PP+1]=11)AND(CAT[PP+2]=6)THEN BEGIN TOKMEM[TOKPTR]:=
40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
RED(PP,3,2,-1);{PROD(36)};
GOTO 31;
END ELSE IF CAT[PP+1]=19 THEN BEGIN IF CAT[PP+2]=3 THEN BEGIN TOKMEM[
TOKPTR]:=133;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
RED(PP+1,2,2,0);{PROD(37)};
GOTO 31;
END;
END;
1:{155}IF CAT[PP+1]=6 THEN BEGIN SQ(PP,1,11,-2);{PROD(43)};
GOTO 31;
END ELSE IF CAT[PP+1]=14 THEN BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,3,-3);
{PROD(44)};
GOTO 31;
END ELSE IF CAT[PP+1]=2 THEN BEGIN SQ(PP,2,2,-1);
{PROD(45)};
GOTO 31;
END ELSE IF CAT[PP+1]=22 THEN BEGIN SQ(PP,2,22,0);
{PROD(46)};
GOTO 31;
END ELSE IF CAT[PP+1]=1 THEN BEGIN SQ(PP,2,1,-2);
{PROD(47)};
GOTO 31;
END ELSE IF CAT[PP+1]=10 THEN BEGIN SQ(PP,2,11,-2);
{PROD(48)};
GOTO 31;
END;
OTHERS:END;
PP:=PP+1;
31:END;
FUNCTION TRANSLATE:TEXTPOINTER;
LABEL 30,31;
VAR I:1..MAXSCRAPS;
K:0..LONGBUFSIZE;
BEGIN PP:=SCRAPBASE;
LOPTR:=PP-1;
HIPTR:=PP;
{171}{IF TRACING=2 THEN BEGIN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'Tracing after l.',LINE:0,':');
END;
IF LOC>50 THEN BEGIN WRITE(TERMOUT,'...');
FOR K:=LOC-50 TO LOC DO WRITE(TERMOUT,XCHR[BUFFER[K-1]]);
END ELSE FOR K:=1 TO LOC DO WRITE(TERMOUT,XCHR[BUFFER[K-1]]);
END};
{163}WHILE TRUE DO BEGIN{164}IF LOPTR<PP+3 THEN BEGIN REPEAT IF HIPTR<=
SCRAPPTR THEN BEGIN LOPTR:=LOPTR+1;
CAT[LOPTR]:=CAT[HIPTR];
TRANS[LOPTR]:=TRANS[HIPTR];
HIPTR:=HIPTR+1;
END;
UNTIL(HIPTR>SCRAPPTR)OR(LOPTR=PP+3);
FOR I:=LOPTR+1 TO PP+3 DO CAT[I]:=0;
END;
IF(TOKPTR+8>MAXTOKS)OR(TEXTPTR+4>MAXTEXTS)THEN BEGIN{IF TOKPTR>MAXTOKPTR
THEN MAXTOKPTR:=TOKPTR;
IF TEXTPTR>MAXTXTPTR THEN MAXTXTPTR:=TEXTPTR;
}BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token/text',' capacity exceeded');
ERROR;
QUIT;
END;
END;
IF PP>LOPTR THEN GOTO 30;
{137}IF CAT[PP]<=7 THEN SIXCASES ELSE BEGIN CASE CAT[PP]OF 17:{141}IF
CAT[PP+1]=21 THEN BEGIN IF CAT[PP+2]=13 THEN BEGIN TOKMEM[TOKPTR]:=
40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
RED(PP,3,17,0);
{PROD(7)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=6 THEN BEGIN IF CAT[PP+2]=10 THEN BEGIN TOKMEM[
TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
RED(PP,3,11,-2);
{PROD(8)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,17,0);
{PROD(9)};
GOTO 31;
END;
21:{142}IF CAT[PP+1]=13 THEN BEGIN SQ(PP,2,17,0);
{PROD(10)};
GOTO 31;
END;
13:{143}IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
RED(PP,2,11,-2);{PROD(11)};
GOTO 31;
END;
12:{144}IF(CAT[PP+1]=13)AND(CAT[PP+2]=11)THEN IF CAT[PP+3]=20 THEN BEGIN
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+3];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
RED(PP,4,13,-2);
{PROD(12)};
GOTO 31;
END ELSE BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
RED(PP,3,11,-2);{PROD(13)};
GOTO 31;
END;
20:{145}BEGIN SQ(PP,1,3,-3);{PROD(14)};
GOTO 31;
END;
15:{146}IF CAT[PP+1]=2 THEN BEGIN IF CAT[PP+2]=1 THEN BEGIN TOKMEM[
TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
RED(PP,3,2,-1);{PROD(15)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=1 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
RED(PP,2,2,-1);{PROD(16)};
GOTO 31;
END;
22:{149}IF(CAT[PP+1]=10)OR(CAT[PP+1]=9)THEN BEGIN TOKMEM[TOKPTR]:=40960+
TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
RED(PP,2,11,-2);
{PROD(24)};
GOTO 31;
END ELSE BEGIN SQ(PP,1,1,-2);{PROD(25)};
GOTO 31;
END;
16:{152}IF CAT[PP+1]=5 THEN BEGIN IF(CAT[PP+2]=6)AND(CAT[PP+3]=10)THEN
BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=137;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+3];
TOKPTR:=TOKPTR+1;
RED(PP,4,11,-2);
{PROD(38)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,16,-2);
{PROD(39)};
GOTO 31;
END;
18:{153}IF(CAT[PP+1]=3)AND(CAT[PP+2]=21)THEN BEGIN TOKMEM[TOKPTR]:=
40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
RED(PP,3,21,-2);{PROD(40)};
GOTO 31;
END ELSE BEGIN TOKMEM[TOKPTR]:=136;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
RED(PP,1,17,0);{PROD(41)};
GOTO 31;
END;
9:{154}BEGIN SQ(PP,1,10,-3);{PROD(42)};
GOTO 31;
END;
11:{156}IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,11,-2);
{PROD(49)};
GOTO 31;
END;
10:{157}BEGIN SQ(PP,1,11,-2);{PROD(50)};
GOTO 31;
END;
19:{158}IF CAT[PP+1]=5 THEN BEGIN SQ(PP,1,11,-2);{PROD(51)};
GOTO 31;
END ELSE IF CAT[PP+1]=2 THEN BEGIN IF CAT[PP+2]=14 THEN BEGIN TOKMEM[
TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+2];
TOKPTR:=TOKPTR+1;
RED(PP+1,2,3,+1);
{PROD(52)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=1 THEN BEGIN IF CAT[PP+2]=14 THEN BEGIN SQ(PP+1,2,
3,+1);{PROD(53)};
GOTO 31;
END;
END ELSE IF CAT[PP+1]=11 THEN BEGIN TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=140;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=40960+TRANS[PP+1];
TOKPTR:=TOKPTR+1;
RED(PP,2,19,-2);
{PROD(54)};
GOTO 31;
END;
OTHERS:END;
PP:=PP+1;
31:END;
END;
30:;
IF(LOPTR=SCRAPBASE)AND(CAT[LOPTR]<>2)THEN TRANSLATE:=TRANS[LOPTR]ELSE{
169}BEGIN{170}{IF(LOPTR>SCRAPBASE)AND(TRACING=1)THEN BEGIN BEGIN WRITELN
(TERMOUT);
WRITE(TERMOUT,'Irreducible scrap sequence in module ',MODULECOUNT:0);
END;
WRITELN(TERMOUT,':');
FOR PP:=SCRAPBASE TO LOPTR DO BEGIN WRITE(TERMOUT,' ');
PRINTCAT(CAT[PP]);
END;
END;};
FOR PP:=SCRAPBASE TO LOPTR DO BEGIN IF PP<>SCRAPBASE THEN BEGIN TOKMEM[
TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
END;
IF CAT[PP]=2 THEN BEGIN TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
END;
TOKMEM[TOKPTR]:=40960+TRANS[PP];
TOKPTR:=TOKPTR+1;
IF CAT[PP]=2 THEN BEGIN TOKMEM[TOKPTR]:=36;
TOKPTR:=TOKPTR+1;
END;
IF TOKPTR+6>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
END;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
TRANSLATE:=TEXTPTR-1;
END;
END;
{172}{183}PROCEDURE APPCOMMENT;
BEGIN TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
IF(SCRAPPTR<SCRAPBASE)OR(CAT[SCRAPPTR]<8)OR(CAT[SCRAPPTR]>10)THEN BEGIN
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=10;
TRANS[SCRAPPTR]:=0;
END ELSE BEGIN TOKMEM[TOKPTR]:=40960+TRANS[SCRAPPTR];
TOKPTR:=TOKPTR+1;
END;
TOKMEM[TOKPTR]:=TEXTPTR+40959;
TOKPTR:=TOKPTR+1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;{175}PROCEDURE EASYCASES;
BEGIN CASE NEXTCONTROL OF 6:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=105;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=110;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
32:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=116;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=111;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
35,36,37,94:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=NEXTCONTROL;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
0,124,131,132,133:;
40,91:BEGIN TOKMEM[TOKPTR]:=NEXTCONTROL;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=4;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
41,93:BEGIN TOKMEM[TOKPTR]:=NEXTCONTROL;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=6;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
42:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=97;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=115;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=116;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
44:BEGIN TOKMEM[TOKPTR]:=44;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=138;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=57;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
46,48,49,50,51,52,53,54,55,56,57:BEGIN TOKMEM[TOKPTR]:=NEXTCONTROL;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
59:BEGIN TOKMEM[TOKPTR]:=59;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=9;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
58:BEGIN TOKMEM[TOKPTR]:=58;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=14;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;{177}26:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=73;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
28:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=76;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
29:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=71;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
30:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=83;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
4:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=87;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
31:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=86;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
5:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=82;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
24:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=75;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
11:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=94;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
128:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=69;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=123;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=15;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
9:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=66;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
10:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=84;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
12:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=79;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
135:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=44;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
136:BEGIN TOKMEM[TOKPTR]:=138;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=48;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
137:BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
APPCOMMENT;
END;
138:BEGIN TOKMEM[TOKPTR]:=142;
TOKPTR:=TOKPTR+1;
APPCOMMENT;
END;
139:BEGIN TOKMEM[TOKPTR]:=134;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
BEGIN TOKMEM[TOKPTR]:=134;
TOKPTR:=TOKPTR+1;
APPCOMMENT;
END;
END;
140:BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=9;
TRANS[SCRAPPTR]:=0;
END;
127:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=74;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
OTHERS:BEGIN TOKMEM[TOKPTR]:=NEXTCONTROL;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END END;
END;
PROCEDURE PASCALPARSE;
LABEL 21,10;
VAR J:0..LONGBUFSIZE;
P:NAMEPOINTER;
BEGIN WHILE NEXTCONTROL<141 DO BEGIN{174}{176}IF(SCRAPPTR+4>MAXSCRAPS)OR
(TOKPTR+6>MAXTOKS)OR(TEXTPTR+4>MAXTEXTS)THEN BEGIN{IF SCRAPPTR>MAXSCRPTR
THEN MAXSCRPTR:=SCRAPPTR;
IF TOKPTR>MAXTOKPTR THEN MAXTOKPTR:=TOKPTR;
IF TEXTPTR>MAXTXTPTR THEN MAXTXTPTR:=TEXTPTR;}BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','scrap/token/text',' capacity exceeded');
ERROR;
QUIT;
END;
END;
21:CASE NEXTCONTROL OF 129:{178}BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=46;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=123;
TOKPTR:=TOKPTR+1;
J:=IDFIRST;
WHILE J<IDLOC DO BEGIN CASE BUFFER[J]OF 32,92,35,37,36,94,39,96,123,125,
126,38,95,24,14,1,22,26,11,29,28:BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
END;
64:IF BUFFER[J+1]=64 THEN J:=J+1 ELSE BEGIN IF NOT PHASEONE THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! Double @ should be used in strings');
ERROR;
END;
END;
25:;
OTHERS:IF BUFFER[J]<32 THEN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! This character shouldn''t be used in strings');
ERROR;
END;
END END;
BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=BUFFER[J];
TOKPTR:=TOKPTR+1;
END;
J:=J+1;
END;
BEGIN TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
130:{180}BEGIN P:=IDLOOKUP(0);
CASE ILK[P]OF 0:BEGIN TOKMEM[TOKPTR]:=10240+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
4:BEGIN TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=7;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
7:BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
8:BEGIN TOKMEM[TOKPTR]:=131;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
9:BEGIN TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=8;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
12:BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=7;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
13:BEGIN TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
16:BEGIN TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
20:BEGIN TOKMEM[TOKPTR]:=132;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
{181}5:BEGIN BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=5;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=0;
END;
END;
6:BEGIN BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=21;
TRANS[SCRAPPTR]:=0;
END;
BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=7;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
10:BEGIN{182}IF(SCRAPPTR<SCRAPBASE)OR((CAT[SCRAPPTR]<>10)AND(CAT[
SCRAPPTR]<>9))THEN BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=10;
TRANS[SCRAPPTR]:=0;
END;
BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=20;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
11:BEGIN{182}IF(SCRAPPTR<SCRAPBASE)OR((CAT[SCRAPPTR]<>10)AND(CAT[
SCRAPPTR]<>9))THEN BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=10;
TRANS[SCRAPPTR]:=0;
END;
BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=6;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
14:BEGIN BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=12;
TRANS[SCRAPPTR]:=0;
END;
BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=7;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
23:BEGIN BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=33;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=7;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=8;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
17:BEGIN BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=16;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN TOKMEM[TOKPTR]:=136;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=32;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
18:BEGIN BEGIN TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=18;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=0;
END;
END;
19:BEGIN BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=136;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=5;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=0;
END;
END;
21:BEGIN{182}IF(SCRAPPTR<SCRAPBASE)OR((CAT[SCRAPPTR]<>10)AND(CAT[
SCRAPPTR]<>9))THEN BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=10;
TRANS[SCRAPPTR]:=0;
END;
BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=6;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=13;
TRANS[SCRAPPTR]:=0;
END;
END;
22:BEGIN BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=20480+P;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=19;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=0;
END;
END;
OTHERS:BEGIN NEXTCONTROL:=ILK[P]-24;
GOTO 21;
END END;
END;
134:{179}BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=104;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=98;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=111;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=120;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=123;
TOKPTR:=TOKPTR+1;
FOR J:=IDFIRST TO IDLOC-1 DO BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=BUFFER[J];
TOKPTR:=TOKPTR+1;
END;
BEGIN TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=1;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
OTHERS:EASYCASES END;
NEXTCONTROL:=GETNEXT;
IF(NEXTCONTROL=124)OR(NEXTCONTROL=123)THEN GOTO 10;
END;
10:END;{184}FUNCTION PASCALTRANSL:TEXTPOINTER;
VAR P:TEXTPOINTER;
SAVEBASE:0..MAXSCRAPS;
BEGIN SAVEBASE:=SCRAPBASE;
SCRAPBASE:=SCRAPPTR+1;
PASCALPARSE;
IF NEXTCONTROL<>124 THEN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Missing "|" after PASCAL text');
ERROR;
END;
END;
BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=135;
TOKPTR:=TOKPTR+1;
END;
APPCOMMENT;
P:=TRANSLATE;
{IF SCRAPPTR>MAXSCRPTR THEN MAXSCRPTR:=SCRAPPTR;}SCRAPPTR:=SCRAPBASE-1;
SCRAPBASE:=SAVEBASE;
PASCALTRANSL:=P;
END;
{185}PROCEDURE OUTERPARSE;
VAR BAL:EIGHTBITS;
P,Q:TEXTPOINTER;
BEGIN WHILE NEXTCONTROL<141 DO IF NEXTCONTROL<>123 THEN PASCALPARSE ELSE
BEGIN{186}IF(TOKPTR+7>MAXTOKS)OR(TEXTPTR+3>MAXTEXTS)OR(SCRAPPTR>=
MAXSCRAPS)THEN BEGIN{IF SCRAPPTR>MAXSCRPTR THEN MAXSCRPTR:=SCRAPPTR;
IF TOKPTR>MAXTOKPTR THEN MAXTOKPTR:=TOKPTR;
IF TEXTPTR>MAXTXTPTR THEN MAXTXTPTR:=TEXTPTR;}BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token/text/scrap',' capacity exceeded');
ERROR;
QUIT;
END;
END;
TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=67;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=123;
TOKPTR:=TOKPTR+1;
BAL:=COPYCOMMENT(1);
NEXTCONTROL:=124;
WHILE BAL>0 DO BEGIN P:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
Q:=PASCALTRANSL;
TOKMEM[TOKPTR]:=40960+P;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=51200+Q;
TOKPTR:=TOKPTR+1;
IF NEXTCONTROL=124 THEN BAL:=COPYCOMMENT(BAL)ELSE BAL:=0;
END;
TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
APPCOMMENT;
END;
END;
{191}PROCEDURE PUSHLEVEL(P:TEXTPOINTER);
BEGIN IF STACKPTR=STACKSIZE THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','stack',' capacity exceeded');
ERROR;
QUIT;
END ELSE BEGIN IF STACKPTR>0 THEN STACK[STACKPTR]:=CURSTATE;
STACKPTR:=STACKPTR+1;
{IF STACKPTR>MAXSTACKPTR THEN MAXSTACKPTR:=STACKPTR;
}CURSTATE.TOKFIELD:=TOKSTART[P];
CURSTATE.ENDFIELD:=TOKSTART[P+1];
END;
END;{193}FUNCTION GETOUTPUT:EIGHTBITS;
LABEL 20;
VAR A:SIXTEENBITS;
BEGIN 20:WHILE CURSTATE.TOKFIELD=CURSTATE.ENDFIELD DO BEGIN STACKPTR:=
STACKPTR-1;
CURSTATE:=STACK[STACKPTR];
END;
A:=TOKMEM[CURSTATE.TOKFIELD];
CURSTATE.TOKFIELD:=CURSTATE.TOKFIELD+1;
IF A>=256 THEN BEGIN CURNAME:=A MOD 10240;
CASE A DIV 10240 OF 2:A:=129;
3:A:=128;
4:BEGIN PUSHLEVEL(CURNAME);
GOTO 20;
END;
5:BEGIN PUSHLEVEL(CURNAME);
CURSTATE.MODEFIELD:=INNER;
GOTO 20;
END;
OTHERS:A:=130 END;
END;{IF TROUBLESHOOT THEN DEBUGHELP;}GETOUTPUT:=A;
END;
{194}PROCEDURE MAKEOUTPUT;
FORWARD;
PROCEDURE OUTPUTPASCAL;
VAR SAVETOKPTR,SAVETEXTPTR,SAVENEXTCONT:SIXTEENBITS;
P:TEXTPOINTER;
BEGIN SAVETOKPTR:=TOKPTR;
SAVETEXTPTR:=TEXTPTR;
SAVENEXTCONT:=NEXTCONTROL;
NEXTCONTROL:=124;
P:=PASCALTRANSL;
TOKMEM[TOKPTR]:=P+51200;
TOKPTR:=TOKPTR+1;
MAKEOUTPUT;
{IF TEXTPTR>MAXTXTPTR THEN MAXTXTPTR:=TEXTPTR;
IF TOKPTR>MAXTOKPTR THEN MAXTOKPTR:=TOKPTR;}TEXTPTR:=SAVETEXTPTR;
TOKPTR:=SAVETOKPTR;
NEXTCONTROL:=SAVENEXTCONT;
END;
{195}PROCEDURE MAKEOUTPUT;
LABEL 21,10,31;
VAR A:EIGHTBITS;
B:EIGHTBITS;
K,KLIMIT:0..MAXBYTES;
J:0..LONGBUFSIZE;
STRINGDELIMI:ASCIICODE;
SAVELOC,SAVELIMIT:0..LONGBUFSIZE;
CURMODNAME:NAMEPOINTER;
SAVEMODE:MODE;
BEGIN TOKMEM[TOKPTR]:=143;
TOKPTR:=TOKPTR+1;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
PUSHLEVEL(TEXTPTR-1);
WHILE TRUE DO BEGIN A:=GETOUTPUT;
21:CASE A OF 143:GOTO 10;
130,129:{196}BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
END;
IF A=130 THEN IF BYTESTART[CURNAME+1]-BYTESTART[CURNAME]=1 THEN BEGIN IF
OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=124;
END ELSE BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
END ELSE BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=38;
END;
IF BYTESTART[CURNAME+1]-BYTESTART[CURNAME]=1 THEN BEGIN IF OUTPTR=
LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=BYTEMEM[BYTESTART[CURNAME]];
END ELSE OUTNAME(CURNAME);
END;
128:{200}BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=88;
END;
IF XMEM[XREF[CURNAME]].NUMFIELD>=10240 THEN OUTVAL(XMEM[XREF[CURNAME]].
NUMFIELD-10240)ELSE BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=48;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=58;
END;{201}K:=BYTESTART[CURNAME];
KLIMIT:=BYTESTART[CURNAME+1];
CURMODNAME:=CURNAME;
WHILE K<KLIMIT DO BEGIN B:=BYTEMEM[K];
K:=K+1;
IF B=64 THEN{202}BEGIN IF BYTEMEM[K]<>64 THEN BEGIN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Illegal control code in module name:');
END;
BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'<');
END;
PRINTID(CURMODNAME);
WRITE(TERMOUT,'> ');
END;
K:=K+1;
END;
IF B<>124 THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=B;
END ELSE BEGIN{203}J:=LIMIT+1;
BUFFER[J]:=124;
STRINGDELIMI:=0;
WHILE TRUE DO BEGIN IF K>=KLIMIT THEN BEGIN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! PASCAL text in module name didn''t end:');
END;
BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'<');
END;
PRINTID(CURMODNAME);
WRITE(TERMOUT,'> ');
GOTO 31;
END;
B:=BYTEMEM[K];
K:=K+1;
IF B=64 THEN{204}BEGIN IF J>LONGBUFSIZE-4 THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','buffer',' capacity exceeded');
ERROR;
QUIT;
END;
BUFFER[J+1]:=64;
BUFFER[J+2]:=BYTEMEM[K];
J:=J+2;
K:=K+1;
END ELSE BEGIN IF(B=34)OR(B=39)THEN IF STRINGDELIMI=0 THEN STRINGDELIMI
:=B ELSE IF STRINGDELIMI=B THEN STRINGDELIMI:=0;
IF(B<>124)OR(STRINGDELIMI<>0)THEN BEGIN IF J>LONGBUFSIZE-3 THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','buffer',' capacity exceeded');
ERROR;
QUIT;
END;
J:=J+1;
BUFFER[J]:=B;
END ELSE GOTO 31;
END;
END;
31:;
SAVELOC:=LOC;
SAVELIMIT:=LIMIT;
LOC:=LIMIT+2;
LIMIT:=J+1;
BUFFER[LIMIT]:=124;
OUTPUTPASCAL;
LOC:=SAVELOC;
LIMIT:=SAVELIMIT;
END;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=88;
END;
END;
131,133,132:{197}BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=109;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=97;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=116;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=104;
END;
IF A=131 THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=98;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=105;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=110;
END ELSE IF A=132 THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=114;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=101;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=108;
END ELSE BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=111;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=112;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=123;
END;
END;
135:BEGIN REPEAT A:=GETOUTPUT;
UNTIL(A<139)OR(A>142);
GOTO 21;
END;
134:BEGIN REPEAT A:=GETOUTPUT;
UNTIL((A<139)AND(A<>32))OR(A>142);
GOTO 21;
END;
136,137,138,139,140,141,142:{198}IF A<140 THEN BEGIN IF CURSTATE.
MODEFIELD=OUTER THEN BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=A-87;
END;
IF A=138 THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=GETOUTPUT;
END END ELSE IF A=138 THEN B:=GETOUTPUT END ELSE{199}BEGIN B:=A;
SAVEMODE:=CURSTATE.MODEFIELD;
WHILE TRUE DO BEGIN A:=GETOUTPUT;
IF(A=135)OR(A=134)THEN GOTO 21;
IF((A<>32)AND(A<140))OR(A>142)THEN BEGIN IF SAVEMODE=OUTER THEN BEGIN IF
OUTPTR>3 THEN IF(OUTBUF[OUTPTR]=80)AND(OUTBUF[OUTPTR-1]=92)AND(OUTBUF[
OUTPTR-2]=89)AND(OUTBUF[OUTPTR-3]=92)THEN GOTO 21;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=B-87;
END;
IF A<>143 THEN FINISHLINE;
END ELSE IF(A<>143)AND(CURSTATE.MODEFIELD=INNER)THEN BEGIN IF OUTPTR=
LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=32;
END;
GOTO 21;
END;
IF A>B THEN B:=A;
END;
END;
OTHERS:BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=A;
END END;
END;
10:END;
{211}PROCEDURE FINISHPASCAL;
VAR P:TEXTPOINTER;
BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=80;
END;
BEGIN IF TOKPTR+2>MAXTOKS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','token',' capacity exceeded');
ERROR;
QUIT;
END;
TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
END;
APPCOMMENT;
P:=TRANSLATE;
TOKMEM[TOKPTR]:=P+40960;
TOKPTR:=TOKPTR+1;
MAKEOUTPUT;
IF OUTPTR>1 THEN IF OUTBUF[OUTPTR-1]=92 THEN IF OUTBUF[OUTPTR]=54 THEN
OUTPTR:=OUTPTR-2 ELSE IF OUTBUF[OUTPTR]=55 THEN OUTBUF[OUTPTR]:=89;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=112;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=97;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=114;
END;
FINISHLINE;
{IF TEXTPTR>MAXTXTPTR THEN MAXTXTPTR:=TEXTPTR;
IF TOKPTR>MAXTOKPTR THEN MAXTOKPTR:=TOKPTR;
IF SCRAPPTR>MAXSCRPTR THEN MAXSCRPTR:=SCRAPPTR;}TOKPTR:=1;
TEXTPTR:=1;
SCRAPPTR:=0;
END;{219}PROCEDURE FOOTNOTE(FLAG:SIXTEENBITS);
LABEL 30;
VAR P,Q,R:0..MAXREFS;
BEGIN FINISHLINE;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
END;
IF FLAG=0 THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=85;
END ELSE BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=65;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=32;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=115;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=101;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=99;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=116;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=105;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=111;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=110;
END;{220}Q:=0;
P:=CURXREF;
REPEAT R:=XMEM[P].XLINKFIELD;
XMEM[P].XLINKFIELD:=Q;
Q:=P;
P:=R;
UNTIL XMEM[P].NUMFIELD<=FLAG;
XMEM[CURXREF].XLINKFIELD:=P;{221}P:=Q;
IF P<>CURXREF THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=115;
END;
WHILE TRUE DO BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=32;
END;
OUTVAL(XMEM[P].NUMFIELD-FLAG);
IF P=CURXREF THEN GOTO 30;
P:=XMEM[P].XLINKFIELD;
IF(P<>CURXREF)OR(P<>XMEM[Q].XLINKFIELD)THEN BEGIN IF OUTPTR=LINELENGTH
THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=44;
END;
IF P=CURXREF THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=32;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=97;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=110;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=100;
END;
END;
30:;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=46;
END;
END;{229}PROCEDURE UNBUCKET(D:EIGHTBITS);
VAR C:ASCIICODE;
BEGIN FOR C:=100 DOWNTO 0 DO IF BUCKET[COLLATE[C]]>0 THEN BEGIN IF
SCRAPPTR>MAXSCRAPS THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','sorting',' capacity exceeded');
ERROR;
QUIT;
END;
SCRAPPTR:=SCRAPPTR+1;
{IF SCRAPPTR>MAXSORTPTR THEN MAXSORTPTR:=SCRAPPTR;
}IF C=0 THEN CAT[SCRAPPTR]:=255 ELSE CAT[SCRAPPTR]:=D;
TRANS[SCRAPPTR]:=BUCKET[COLLATE[C]];
BUCKET[COLLATE[C]]:=0;
END;
END;
{237}PROCEDURE MODPRINT(P:NAMEPOINTER);
BEGIN IF P>0 THEN BEGIN MODPRINT(LINK[P]);
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=43;
END;
TOKPTR:=1;
TEXTPTR:=1;
SCRAPPTR:=0;
STACKPTR:=0;
CURSTATE.MODEFIELD:=OUTER;
TOKMEM[TOKPTR]:=P+30720;
TOKPTR:=TOKPTR+1;
MAKEOUTPUT;
FINISHLINE;
MODPRINT(ILK[P]);
END;
END;
{241}{PROCEDURE DEBUGHELP;
LABEL 889,888,10;
VAR K:SIXTEENBITS;
BEGIN DEBUGSKIPPED:=DEBUGSKIPPED+1;
IF DEBUGSKIPPED<DEBUGCYCLE THEN GOTO 10;
DEBUGSKIPPED:=0;
GOTO 889;
888:['*************breakpoint*************';
'***********for**debugging***********'];
889:WHILE TRUE DO BEGIN WRITE(TERMOUT,'#');
BREAK(TERMOUT);
READ(TERMIN,DDT);
IF DDT<0 THEN GOTO 10 ELSE IF DDT=0 THEN GOTO 888;
READ(TERMIN,DD);
CASE DDT OF 1:PRINTID(DD);
2:PRINTTEXT(DD);
3:FOR K:=1 TO DD DO WRITE(TERMOUT,XCHR[BUFFER[K]]);
4:FOR K:=1 TO DD DO WRITE(TERMOUT,XCHR[MODTEXT[K]]);
5:FOR K:=1 TO OUTPTR DO WRITE(TERMOUT,XCHR[OUTBUF[K]]);
6:FOR K:=1 TO DD DO BEGIN PRINTCAT(CAT[K]);
WRITE(TERMOUT,' ');
END;
OTHERS:WRITE(TERMOUT,'?')END;
END;
10:END;}{242}PROCEDURE PHASEI;
BEGIN{97}PHASEONE:=TRUE;
RESETINPUT;
MODULECOUNT:=0;
REPEAT SKIPLIMBO;
IF NOT INPUTHASENDE THEN REPEAT{98}IF MODULECOUNT<10239 THEN MODULECOUNT
:=MODULECOUNT+1 ELSE BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Sorry, ','module number',' capacity exceeded');
ERROR;
QUIT;
END;
IF BUFFER[LOC-1]=42 THEN BEGIN WRITE(TERMOUT,'*',MODULECOUNT:0);
BREAK(TERMOUT);
END;{101}REPEAT NEXTCONTROL:=SKIPTEX;
CASE NEXTCONTROL OF 126:XREFSWITCH:=10240;
125:XREFSWITCH:=0;
124:PASCALXREF;
131,132,133,144:BEGIN LOC:=LOC-2;
NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL<>144 THEN NEWXREF(IDLOOKUP(NEXTCONTROL-130));
END;
OTHERS:END;
UNTIL NEXTCONTROL>=141;
{103}WHILE NEXTCONTROL<=142 DO BEGIN XREFSWITCH:=10240;
IF NEXTCONTROL=142 THEN NEXTCONTROL:=GETNEXT ELSE{104}BEGIN NEXTCONTROL
:=GETNEXT;
IF NEXTCONTROL=130 THEN BEGIN LHS:=IDLOOKUP(0);
ILK[LHS]:=0;
NEWXREF(LHS);
NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL=30 THEN BEGIN NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL=130 THEN BEGIN RHS:=IDLOOKUP(0);
ILK[LHS]:=ILK[RHS];
ILK[RHS]:=0;
NEWXREF(RHS);
ILK[RHS]:=ILK[LHS];
NEXTCONTROL:=GETNEXT;
END;
END;
END;
END;
OUTERXREF;
END;
{105}IF NEXTCONTROL<=144 THEN BEGIN IF NEXTCONTROL=143 THEN MODXREFSWITC
:=0 ELSE MODXREFSWITC:=10240;
REPEAT IF NEXTCONTROL=144 THEN NEWMODXREF(CURMODULE);
NEXTCONTROL:=GETNEXT;
OUTERXREF;
UNTIL NEXTCONTROL>144;
END;
UNTIL NEXTCONTROL=145;
UNTIL INPUTHASENDE;
PHASEONE:=FALSE;
{108}MODCHECK(ILK[0]);
END;
PROCEDURE PHASEII;
BEGIN{205}RESETINPUT;
BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'Writing the output file...');
END;
MODULECOUNT:=0;
REPEAT COPYLIMBO;
IF NOT INPUTHASENDE THEN BEGIN REPEAT{207}MODULECOUNT:=MODULECOUNT+1;
{208}FINISHLINE;
FLUSHBUFFER(0);
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
END;
IF BUFFER[LOC-1]<>42 THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=77;
END ELSE BEGIN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=78;
END;
WRITE(TERMOUT,'*',MODULECOUNT:0);
BREAK(TERMOUT);
END;
OUTVAL(MODULECOUNT);
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=46;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=32;
END;
SAVELINE:=OUTLINE;
SAVEPLACE:=OUTPTR;
{209}REPEAT NEXTCONTROL:=COPYTEX;
CASE NEXTCONTROL OF 124:BEGIN STACKPTR:=0;
CURSTATE.MODEFIELD:=OUTER;
OUTPUTPASCAL;
END;
64:BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=64;
END;
12:BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=79;
END;
134,131,132,133,144:BEGIN LOC:=LOC-2;
NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL=134 THEN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT
);
WRITE(TERMOUT,'! TEX string should be in PASCAL text only');
ERROR;
END;
END;
END;
9,10,135,136,137,138,139,127,140:BEGIN IF NOT PHASEONE THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! You can''t do that in TEX text');
ERROR;
END;
END;
OTHERS:END;
UNTIL NEXTCONTROL>=141;
{210}IF NEXTCONTROL<=142 THEN BEGIN IF(SAVELINE<>OUTLINE)OR(SAVEPLACE<>
OUTPTR)THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=89;
END;
SAVELINE:=OUTLINE;
SAVEPLACE:=OUTPTR;
END;
WHILE NEXTCONTROL<=142 DO BEGIN STACKPTR:=0;
CURSTATE.MODEFIELD:=OUTER;
IF NEXTCONTROL=142 THEN{212}BEGIN BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=68;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL<>130 THEN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(
TERMOUT);
WRITE(TERMOUT,'! Improper macro definition');
ERROR;
END;
END ELSE BEGIN TOKMEM[TOKPTR]:=10240+IDLOOKUP(0);
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
NEXTCONTROL:=GETNEXT;
END ELSE{213}BEGIN BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=70;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=3;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL=130 THEN BEGIN BEGIN TOKMEM[TOKPTR]:=10240+IDLOOKUP(0);
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL=30 THEN BEGIN BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=83;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
NEXTCONTROL:=GETNEXT;
IF NEXTCONTROL=130 THEN BEGIN BEGIN TOKMEM[TOKPTR]:=10240+IDLOOKUP(0);
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=9;
TRANS[SCRAPPTR]:=0;
END;
NEXTCONTROL:=GETNEXT;
END;
END;
END;
IF SCRAPPTR<>5 THEN BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Improper format definition');
ERROR;
END;
END;
END;
OUTERPARSE;
FINISHPASCAL;
END;{215}THISMODULE:=0;
IF NEXTCONTROL<=144 THEN BEGIN IF(SAVELINE<>OUTLINE)OR(SAVEPLACE<>OUTPTR
)THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=89;
END;
STACKPTR:=0;
CURSTATE.MODEFIELD:=OUTER;
IF NEXTCONTROL=143 THEN NEXTCONTROL:=GETNEXT ELSE BEGIN THISMODULE:=
CURMODULE;{216}REPEAT NEXTCONTROL:=GETNEXT;
UNTIL NEXTCONTROL<>43;
IF(NEXTCONTROL<>61)AND(NEXTCONTROL<>30)THEN BEGIN IF NOT PHASEONE THEN
BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! You need an = sign after the module name');
ERROR;
END;
END ELSE NEXTCONTROL:=GETNEXT;
IF OUTPTR>1 THEN IF(OUTBUF[OUTPTR]=89)AND(OUTBUF[OUTPTR-1]=92)THEN BEGIN
TOKMEM[TOKPTR]:=139;
TOKPTR:=TOKPTR+1;
END;
BEGIN TOKMEM[TOKPTR]:=30720+THISMODULE;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=22;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
CURXREF:=XREF[THISMODULE];
IF XMEM[CURXREF].NUMFIELD<>MODULECOUNT+10240 THEN BEGIN BEGIN TOKMEM[
TOKPTR]:=132;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=43;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=125;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
THISMODULE:=0;
END;
BEGIN TOKMEM[TOKPTR]:=92;
TOKPTR:=TOKPTR+1;
TOKMEM[TOKPTR]:=83;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=2;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
BEGIN TOKMEM[TOKPTR]:=141;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=9;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
END;
WHILE NEXTCONTROL<=144 DO BEGIN OUTERPARSE;
{217}IF NEXTCONTROL<144 THEN BEGIN BEGIN IF NOT PHASEONE THEN BEGIN
WRITELN(TERMOUT);
WRITE(TERMOUT,'! You can''t do that in PASCAL text');
ERROR;
END;
END;
NEXTCONTROL:=GETNEXT;
END ELSE IF NEXTCONTROL=144 THEN BEGIN BEGIN TOKMEM[TOKPTR]:=30720+
CURMODULE;
TOKPTR:=TOKPTR+1;
SCRAPPTR:=SCRAPPTR+1;
CAT[SCRAPPTR]:=22;
TRANS[SCRAPPTR]:=TEXTPTR;
TEXTPTR:=TEXTPTR+1;
TOKSTART[TEXTPTR]:=TOKPTR;
END;
NEXTCONTROL:=GETNEXT;
END;
END;
FINISHPASCAL;
END;
{218}IF THISMODULE>0 THEN BEGIN CURXREF:=XMEM[CURXREF].XLINKFIELD;
IF XMEM[CURXREF].NUMFIELD>=10240 THEN BEGIN FOOTNOTE(10240);
CURXREF:=XMEM[CURXREF].XLINKFIELD;
END;
IF CURXREF<>0 THEN FOOTNOTE(0);
END;
UNTIL NEXTCONTROL=145;
END;
UNTIL INPUTHASENDE;
END;
BEGIN INITIALIZE;
WRITELN(TERMOUT,'This is WEAVE, Version 0.9');{58}IDLOC:=10;
IDFIRST:=7;
BUFFER[7]:=97;
BUFFER[8]:=110;
BUFFER[9]:=100;
CURNAME:=IDLOOKUP(28);
IDFIRST:=5;
BUFFER[5]:=97;
BUFFER[6]:=114;
BUFFER[7]:=114;
BUFFER[8]:=97;
BUFFER[9]:=121;
CURNAME:=IDLOOKUP(4);
IDFIRST:=5;
BUFFER[5]:=98;
BUFFER[6]:=101;
BUFFER[7]:=103;
BUFFER[8]:=105;
BUFFER[9]:=110;
CURNAME:=IDLOOKUP(5);
IDFIRST:=6;
BUFFER[6]:=99;
BUFFER[7]:=97;
BUFFER[8]:=115;
BUFFER[9]:=101;
CURNAME:=IDLOOKUP(6);
IDFIRST:=5;
BUFFER[5]:=99;
BUFFER[6]:=111;
BUFFER[7]:=110;
BUFFER[8]:=115;
BUFFER[9]:=116;
CURNAME:=IDLOOKUP(7);
IDFIRST:=7;
BUFFER[7]:=100;
BUFFER[8]:=105;
BUFFER[9]:=118;
CURNAME:=IDLOOKUP(8);
IDFIRST:=8;
BUFFER[8]:=100;
BUFFER[9]:=111;
CURNAME:=IDLOOKUP(9);
IDFIRST:=4;
BUFFER[4]:=100;
BUFFER[5]:=111;
BUFFER[6]:=119;
BUFFER[7]:=110;
BUFFER[8]:=116;
BUFFER[9]:=111;
CURNAME:=IDLOOKUP(20);
IDFIRST:=6;
BUFFER[6]:=101;
BUFFER[7]:=108;
BUFFER[8]:=115;
BUFFER[9]:=101;
CURNAME:=IDLOOKUP(10);
IDFIRST:=7;
BUFFER[7]:=101;
BUFFER[8]:=110;
BUFFER[9]:=100;
CURNAME:=IDLOOKUP(11);
IDFIRST:=6;
BUFFER[6]:=102;
BUFFER[7]:=105;
BUFFER[8]:=108;
BUFFER[9]:=101;
CURNAME:=IDLOOKUP(4);
IDFIRST:=7;
BUFFER[7]:=102;
BUFFER[8]:=111;
BUFFER[9]:=114;
CURNAME:=IDLOOKUP(12);
IDFIRST:=2;
BUFFER[2]:=102;
BUFFER[3]:=117;
BUFFER[4]:=110;
BUFFER[5]:=99;
BUFFER[6]:=116;
BUFFER[7]:=105;
BUFFER[8]:=111;
BUFFER[9]:=110;
CURNAME:=IDLOOKUP(17);
IDFIRST:=6;
BUFFER[6]:=103;
BUFFER[7]:=111;
BUFFER[8]:=116;
BUFFER[9]:=111;
CURNAME:=IDLOOKUP(13);
IDFIRST:=8;
BUFFER[8]:=105;
BUFFER[9]:=102;
CURNAME:=IDLOOKUP(14);
IDFIRST:=8;
BUFFER[8]:=105;
BUFFER[9]:=110;
CURNAME:=IDLOOKUP(30);
IDFIRST:=5;
BUFFER[5]:=108;
BUFFER[6]:=97;
BUFFER[7]:=98;
BUFFER[8]:=101;
BUFFER[9]:=108;
CURNAME:=IDLOOKUP(7);
IDFIRST:=7;
BUFFER[7]:=109;
BUFFER[8]:=111;
BUFFER[9]:=100;
CURNAME:=IDLOOKUP(8);
IDFIRST:=7;
BUFFER[7]:=110;
BUFFER[8]:=105;
BUFFER[9]:=108;
CURNAME:=IDLOOKUP(16);
IDFIRST:=7;
BUFFER[7]:=110;
BUFFER[8]:=111;
BUFFER[9]:=116;
CURNAME:=IDLOOKUP(29);
IDFIRST:=8;
BUFFER[8]:=111;
BUFFER[9]:=102;
CURNAME:=IDLOOKUP(9);
IDFIRST:=8;
BUFFER[8]:=111;
BUFFER[9]:=114;
CURNAME:=IDLOOKUP(55);
IDFIRST:=4;
BUFFER[4]:=112;
BUFFER[5]:=97;
BUFFER[6]:=99;
BUFFER[7]:=107;
BUFFER[8]:=101;
BUFFER[9]:=100;
CURNAME:=IDLOOKUP(13);
IDFIRST:=1;
BUFFER[1]:=112;
BUFFER[2]:=114;
BUFFER[3]:=111;
BUFFER[4]:=99;
BUFFER[5]:=101;
BUFFER[6]:=100;
BUFFER[7]:=117;
BUFFER[8]:=114;
BUFFER[9]:=101;
CURNAME:=IDLOOKUP(17);
IDFIRST:=3;
BUFFER[3]:=112;
BUFFER[4]:=114;
BUFFER[5]:=111;
BUFFER[6]:=103;
BUFFER[7]:=114;
BUFFER[8]:=97;
BUFFER[9]:=109;
CURNAME:=IDLOOKUP(17);
IDFIRST:=4;
BUFFER[4]:=114;
BUFFER[5]:=101;
BUFFER[6]:=99;
BUFFER[7]:=111;
BUFFER[8]:=114;
BUFFER[9]:=100;
CURNAME:=IDLOOKUP(18);
IDFIRST:=4;
BUFFER[4]:=114;
BUFFER[5]:=101;
BUFFER[6]:=112;
BUFFER[7]:=101;
BUFFER[8]:=97;
BUFFER[9]:=116;
CURNAME:=IDLOOKUP(19);
IDFIRST:=7;
BUFFER[7]:=115;
BUFFER[8]:=101;
BUFFER[9]:=116;
CURNAME:=IDLOOKUP(4);
IDFIRST:=6;
BUFFER[6]:=116;
BUFFER[7]:=104;
BUFFER[8]:=101;
BUFFER[9]:=110;
CURNAME:=IDLOOKUP(9);
IDFIRST:=8;
BUFFER[8]:=116;
BUFFER[9]:=111;
CURNAME:=IDLOOKUP(20);
IDFIRST:=6;
BUFFER[6]:=116;
BUFFER[7]:=121;
BUFFER[8]:=112;
BUFFER[9]:=101;
CURNAME:=IDLOOKUP(7);
IDFIRST:=5;
BUFFER[5]:=117;
BUFFER[6]:=110;
BUFFER[7]:=116;
BUFFER[8]:=105;
BUFFER[9]:=108;
CURNAME:=IDLOOKUP(21);
IDFIRST:=7;
BUFFER[7]:=118;
BUFFER[8]:=97;
BUFFER[9]:=114;
CURNAME:=IDLOOKUP(22);
IDFIRST:=5;
BUFFER[5]:=119;
BUFFER[6]:=104;
BUFFER[7]:=105;
BUFFER[8]:=108;
BUFFER[9]:=101;
CURNAME:=IDLOOKUP(12);
IDFIRST:=6;
BUFFER[6]:=119;
BUFFER[7]:=105;
BUFFER[8]:=116;
BUFFER[9]:=104;
CURNAME:=IDLOOKUP(12);
IDFIRST:=3;
BUFFER[3]:=120;
BUFFER[4]:=99;
BUFFER[5]:=108;
BUFFER[6]:=97;
BUFFER[7]:=117;
BUFFER[8]:=115;
BUFFER[9]:=101;
CURNAME:=IDLOOKUP(23);
PHASEI;
PHASEII;
{222}BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'Writing the index...');
END;
FINISHLINE;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=105;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=110;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=120;
END;
FINISHLINE;{224}FOR C:=0 TO 127 DO BUCKET[C]:=0;
FOR H:=0 TO HASHSIZE-1 DO BEGIN NEXTNAME:=HASH[H];
WHILE NEXTNAME<>0 DO BEGIN CURNAME:=NEXTNAME;
NEXTNAME:=LINK[CURNAME];
IF XREF[CURNAME]<>0 THEN BEGIN C:=BYTEMEM[BYTESTART[CURNAME]];
IF(C<=90)AND(C>=65)THEN C:=C+32;
BLINK[CURNAME]:=BUCKET[C];
BUCKET[C]:=CURNAME;
END;
END;
END;{230}SCRAPPTR:=0;
UNBUCKET(1);
WHILE SCRAPPTR>0 DO BEGIN CURDEPTH:=CAT[SCRAPPTR];
IF(BLINK[TRANS[SCRAPPTR]]=0)OR(CURDEPTH=255)THEN{232}BEGIN CURNAME:=
TRANS[SCRAPPTR];{IF TROUBLESHOOT THEN DEBUGHELP;
}REPEAT BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=43;
END;
{233}CASE ILK[CURNAME]OF 0:IF BYTESTART[CURNAME+1]-BYTESTART[CURNAME]=1
THEN BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=124;
END ELSE BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
END;
1:;
2:BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=57;
END;
3:BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=46;
END;
OTHERS:BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=38;
END END;
OUTNAME(CURNAME);
{234}{236}THISXREF:=XREF[CURNAME];
CURXREF:=0;
REPEAT NEXTXREF:=XMEM[THISXREF].XLINKFIELD;
XMEM[THISXREF].XLINKFIELD:=CURXREF;
CURXREF:=THISXREF;
THISXREF:=NEXTXREF;
UNTIL THISXREF=0;
REPEAT BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=44;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=32;
END;
CURVAL:=XMEM[CURXREF].NUMFIELD;
IF CURVAL<10240 THEN OUTVAL(CURVAL)ELSE BEGIN BEGIN IF OUTPTR=LINELENGTH
THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=91;
END;
OUTVAL(CURVAL-10240);
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=93;
END;
END;
CURXREF:=XMEM[CURXREF].XLINKFIELD;
UNTIL CURXREF=0;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=46;
END;
FINISHLINE;
CURNAME:=BLINK[CURNAME];
UNTIL CURNAME=0;
SCRAPPTR:=SCRAPPTR-1;
END ELSE{231}BEGIN NEXTNAME:=TRANS[SCRAPPTR];
REPEAT CURNAME:=NEXTNAME;
NEXTNAME:=BLINK[CURNAME];
CURBYTE:=BYTESTART[CURNAME]+CURDEPTH;
IF CURBYTE=BYTESTART[CURNAME+1]THEN C:=0 ELSE BEGIN C:=BYTEMEM[CURBYTE];
IF(C<=90)AND(C>=65)THEN C:=C+32;
END;
BLINK[CURNAME]:=BUCKET[C];
BUCKET[C]:=CURNAME;
UNTIL NEXTNAME=0;
SCRAPPTR:=SCRAPPTR-1;
UNBUCKET(CURDEPTH+1);
END;
END;
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=102;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=105;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=110;
END;
FINISHLINE;
{238}MODPRINT(ILK[0]);
BEGIN IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=92;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=99;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=111;
IF OUTPTR=LINELENGTH THEN BREAKOUT;
OUTPTR:=OUTPTR+1;
OUTBUF[OUTPTR]:=110;
END;
FINISHLINE;
WRITE(TERMOUT,'Done.');
{76}IF CHANGELIMIT<>0 THEN BEGIN FOR LOC:=0 TO CHANGELIMIT DO BUFFER[LOC
]:=CHANGEBUFFER[LOC];
LIMIT:=CHANGELIMIT;
CHANGING:=TRUE;
LINE:=OTHERLINE;
BEGIN IF NOT PHASEONE THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! Change file entry did not match');
ERROR;
END;
END;
END;
9999:{[243]BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'Memory usage statistics: ',NAMEPTR:0,' names, ',XREFPTR:0
,' cross references, ',BYTEPTR:0,' bytes;');
END;
BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'parsing required ',MAXSCRPTR:0,' scraps, ',MAXTXTPTR:0,
' texts, ',MAXTOKPTR:0,' tokens, ',MAXSTACKPTR:0,' levels;');
END;
BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'sorting required ',MAXSORTPTR:0,' levels.');
END;}
END.